#!usr/bin/env python  
# -*- coding:utf-8 -*-
""" 
@author:robot
@file: title04微服务的集成测试.py 
@version:
@time: 2023/05/29

https://dream.blog.csdn.net/article/details/129180264

示例1
3
5 0 0
1 5 0
0 1 5
3

15

示例2
3
5 0 0
1 10 1
1 0 11
2

26

示例3
4
2 0 0 0
0 3 0 0
1 1 4 0
1 1 1 5
4

12

思路
1. 首先读取输入，包括服务数量n、服务依赖关系矩阵service_map和目标服务编号target。
2. 根据服务依赖关系矩阵，初始化每个任务的前置依赖任务。
3. 初始化一个服务列表，将目标服务的前置依赖任务加入其中。
4. 初始化总等待时间result为目标服务的执行时间。
5. 循环处理服务列表，每次取出第一个等待服务
6. 对于当前等待服务的前置依赖任务，更新临时等待时间temp_res，即当前等待服务需要等待的最长时间。
7. 对于每个前置依赖任务的前置依赖任务，将其加入下一个等待服务列表中
8. 更新总等待时间result，加上临时等待时间temp_res
9. 如果下一个等待服务列表不能为空，则将其添加到服务列表中
"""


def main():
    n = int(input())
    service_map = [list(map(int, input().split())) for _ in range(n)]
    target = int(input()) - 1  # 服务对于矩阵来说是用索引表示的，所以需要减一

    """
    [
        [],
        [],
        [],
        ...
    ]
    """
    upstream = [[] for _ in range(n)]

    for i in range(n):
        for j in range(n):
            if i != j and service_map[i][j] == 1:  # 当i不等于j但service[i][j]=1那么i依赖于j
                """
                j\i  0  1  2
                 0   5  0  0
                 1   1  5  0 
                 2   0  1  5
                """
                upstream[i].append(j)  # [[],[0],[1]]

    service_list = []
    service_list.append(upstream[target])  # [[1]]

    result = service_map[target][target]  # result = 5

    while service_list:
        upstream_tasks = service_list.pop(0)  # [1]
        temp_res = 0
        services = []
        for i in upstream_tasks:
            temp_res = max(temp_res, service_map[i][i])  # 5
            for j in upstream[i]:  # 轮询依赖的服务，并添加到services
                services.append(j)
        result += temp_res  # 时间叠加
        if services:  # 如果还有依赖服务，添加到service_list
            service_list.append(services)
    print(result)


main()
